#pragma once

#include "strategy/optimized_strategy_base.h"
#include "strategy/optimized_mean_reversion_strategy.h"
#include "strategy/optimized_statistical_arbitrage_strategy.h"
#include "utils/memory_pool.h"
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <mutex>

namespace hft {

/**
 * @brief 优化的策略工厂类
 * 
 * 这个类负责创建和管理优化策略的实例。
 * 它使用内存池来管理策略对象，并提供统一的接口来创建不同类型的优化策略。
 */
class OptimizedStrategyFactory {
public:
    /**
     * @brief 获取工厂实例（单例模式）
     * @return 工厂实例
     */
    static OptimizedStrategyFactory& getInstance() {
        static OptimizedStrategyFactory instance;
        return instance;
    }

    /**
     * @brief 创建均值回归策略
     * @param symbol 交易品种
     * @param window_size 移动平均窗口大小
     * @param entry_threshold 入场阈值
     * @param exit_threshold 出场阈值
     * @return 策略指针
     */
    std::shared_ptr<OptimizedMeanReversionStrategy> createMeanReversionStrategy(
        const std::string& symbol,
        size_t window_size = 20,
        double entry_threshold = 2.0,
        double exit_threshold = 0.5) {
        
        std::lock_guard<std::mutex> lock(mutex_);
        
        // 创建策略实例
        auto strategy = std::make_shared<OptimizedMeanReversionStrategy>(
            symbol, window_size, entry_threshold, exit_threshold);
        
        // 注册策略
        registerStrategy(strategy);
        
        return strategy;
    }

    /**
     * @brief 创建统计套利策略
     * @param symbol1 第一个交易品种
     * @param symbol2 第二个交易品种
     * @param window_size 计算窗口大小
     * @param entry_threshold 入场阈值
     * @param exit_threshold 出场阈值
     * @return 策略指针
     */
    std::shared_ptr<OptimizedStatisticalArbitrageStrategy> createStatisticalArbitrageStrategy(
        const std::string& symbol1,
        const std::string& symbol2,
        size_t window_size = 100,
        double entry_threshold = 2.0,
        double exit_threshold = 0.5) {
        
        std::lock_guard<std::mutex> lock(mutex_);
        
        // 创建策略实例
        auto strategy = std::make_shared<OptimizedStatisticalArbitrageStrategy>(
            symbol1, symbol2, window_size, entry_threshold, exit_threshold);
        
        // 注册策略
        registerStrategy(strategy);
        
        return strategy;
    }

    /**
     * @brief 获取所有策略
     * @return 策略列表
     */
    std::vector<std::shared_ptr<OptimizedStrategyBase>> getAllStrategies() const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        std::vector<std::shared_ptr<OptimizedStrategyBase>> strategies;
        strategies.reserve(strategies_.size());
        
        for (const auto& pair : strategies_) {
            strategies.push_back(pair.second);
        }
        
        return strategies;
    }

    /**
     * @brief 获取指定名称的策略
     * @param name 策略名称
     * @return 策略指针
     */
    std::shared_ptr<OptimizedStrategyBase> getStrategy(const std::string& name) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = strategies_.find(name);
        if (it != strategies_.end()) {
            return it->second;
        }
        
        return nullptr;
    }

    /**
     * @brief 删除策略
     * @param name 策略名称
     */
    void removeStrategy(const std::string& name) {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = strategies_.find(name);
        if (it != strategies_.end()) {
            it->second->stop();
            strategies_.erase(it);
        }
    }

    /**
     * @brief 清除所有策略
     */
    void clearStrategies() {
        std::lock_guard<std::mutex> lock(mutex_);
        
        for (auto& pair : strategies_) {
            pair.second->stop();
        }
        strategies_.clear();
    }

    /**
     * @brief 启动所有策略
     */
    void startAllStrategies() {
        std::lock_guard<std::mutex> lock(mutex_);
        
        for (auto& pair : strategies_) {
            pair.second->start();
        }
    }

    /**
     * @brief 停止所有策略
     */
    void stopAllStrategies() {
        std::lock_guard<std::mutex> lock(mutex_);
        
        for (auto& pair : strategies_) {
            pair.second->stop();
        }
    }

    /**
     * @brief 获取策略状态报告
     * @return JSON格式的状态报告
     */
    std::string getStatusReport() const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        nlohmann::json report;
        report["total_strategies"] = strategies_.size();
        
        nlohmann::json strategies_array = nlohmann::json::array();
        for (const auto& pair : strategies_) {
            nlohmann::json strategy_json = nlohmann::json::parse(pair.second->getState());
            strategies_array.push_back(strategy_json);
        }
        
        report["strategies"] = strategies_array;
        return report.dump(4);
    }

    /**
     * @brief 清理所有策略的未使用内存
     */
    void shrinkMemoryPools() {
        std::lock_guard<std::mutex> lock(mutex_);
        
        for (auto& pair : strategies_) {
            pair.second->shrinkMemoryPools();
        }
    }

private:
    /**
     * @brief 私有构造函数（单例模式）
     */
    OptimizedStrategyFactory() = default;

    /**
     * @brief 注册策略
     * @param strategy 策略指针
     */
    void registerStrategy(std::shared_ptr<OptimizedStrategyBase> strategy) {
        if (!strategy) return;
        
        const std::string& name = strategy->getName();
        auto it = strategies_.find(name);
        
        if (it != strategies_.end()) {
            // 如果已存在同名策略，先停止并移除它
            it->second->stop();
            strategies_.erase(it);
        }
        
        strategies_[name] = strategy;
    }

private:
    std::unordered_map<std::string, std::shared_ptr<OptimizedStrategyBase>> strategies_;  // 策略映射表
    mutable std::mutex mutex_;  // 互斥锁
};

} // namespace hft